package nucleo;

import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

/**
 *
 * @author OsomGames
 * @date 18-07-2011
 */
public class Zona_bk {

    private char[][] mapeado = new char[9][40];
    //private Bloque[] bloques;
    ArrayList<Bloque> bloques = new ArrayList<Bloque>();

    private HashMap<String, Personaje_bk> coleccionPersonajes = new HashMap<String, Personaje_bk>();

    /**
     * Crea un archivo con la zona en un array String
     * @param zona
     * @param fichero 
     */
    public void crearZona(String[] zona, String fichero) {
        try {
            // Crea el archivo
            FileWriter fstream = new FileWriter(fichero);
            // Abre el buffer para escribir
            BufferedWriter out = new BufferedWriter(fstream);
            // Escribe el nivel
            for (int i = 0; i <= zona.length - 1; i++) {
                out.write(zona[i] + "\n");
            }
            // Cierra el buffer
            out.close();
        } catch (Exception e) {
            System.err.println("Error al crear: " + e.getMessage());
        }
    }

    /**
     * Carga la Zona especificada por el fichero
     * @param fichero 
     */
    public void cargarZona(String fichero) {

        try {
            // Leemos el archivo    
            FileReader fstream = new FileReader(new File(fichero));

            // Abrimos el buffer de lectura
            BufferedReader in = new BufferedReader(fstream);

            // Recorremos cada linea, introduciendo cada caracter en una matriz
            mapeado[0] = in.readLine().toCharArray();
            System.out.println(mapeado[0]);
            mapeado[1] = in.readLine().toCharArray();
            System.out.println(mapeado[1]);
            mapeado[2] = in.readLine().toCharArray();
            System.out.println(mapeado[2]);
            mapeado[3] = in.readLine().toCharArray();
            System.out.println(mapeado[3]);
            mapeado[4] = in.readLine().toCharArray();
            System.out.println(mapeado[4]);
            mapeado[5] = in.readLine().toCharArray();
            System.out.println(mapeado[5]);
            mapeado[6] = in.readLine().toCharArray();
            System.out.println(mapeado[6]);
            mapeado[7] = in.readLine().toCharArray();
            System.out.println(mapeado[7]);
            mapeado[8] = in.readLine().toCharArray();
            System.out.println(mapeado[8]);

            // Cerramos el buffer y el archivo
            in.close();
            fstream.close();

            // Y a continuacion cargamos los bloques en su array
           cargarBloques();

        } catch (Exception e) {
            System.err.println("Error al cargar: " + e.getMessage());
        }
    }

    public void pintarZona(Graphics2D g, Applet a) {
        for (Bloque b: bloques){
           g.setColor(Color.black);
           g.fill(b.getBounds());
        }
        System.out.println(coleccionPersonajes.get("asd"));
        if (this.coleccionPersonajes.containsKey("Jugador")) {
            coleccionPersonajes.get("Jugador").pintarPersonaje(g, a);
        }

    }

    /**
     * Metodo usado para añadir un personaje a la zona
     * @param s - Nombre de la clave
     * @param p - Objeto personaje
     */
    public void añadirPersonaje(String s, Personaje_bk p) {
        coleccionPersonajes.put(s, p);
    }

    public void controlarEspacio() {
        Rectangle r = new Rectangle(
                coleccionPersonajes.get("Jugador").getX(), 
                coleccionPersonajes.get("Jugador").getY(), 
                coleccionPersonajes.get("Jugador").getANCHO()+coleccionPersonajes.get("Jugador").getVx(), 
                coleccionPersonajes.get("Jugador").getALTO()+coleccionPersonajes.get("Jugador").getVy()
                );
                
        for (Bloque b: bloques){
           if(b.intersects(r)){
                // Aqui se llama al sistema de colision del personaje
                coleccionPersonajes.get("Jugador").colision(b);
                
           }
        }
    }

    /**
     * Durante la carga de la Zona, se cargan ademas
     * todos los bloques en un array
     * @return Bloque[]
     */
    private void cargarBloques() {
        int inicio = 0;
        int cantidad = 0;
        // Se recorre toda zona (matriz caracteres)
        for (int i = 0; i <= mapeado.length - 1; i++) {
            for (int j = 0; j <= mapeado[i].length - 1; j++) {
                // Si es distinto de '-' (vacio) es que hay algo.
                if (mapeado[i][j] != '-') {
                    if (inicio != 0) {
                        // La cantidad esta para unir los bloques iguales en uno
                        cantidad++;
                        inicio = 0;
                    }
                } else {
                    if (inicio == 0) {
                        inicio = j;
                    }

                }
            }
        }
        System.out.println("Cantidad de bloques: " + (cantidad - 1));
        
        for (int i = 0; i <= mapeado.length - 1; i++) {
            // Y aqui distinguimos lo que nos convenga
            buscarPorFila(mapeado[i], 'A', i);
            buscarPorFila(mapeado[i], 'B', i);
        }

    }
    /**
     * Esta funcion es la que ubica y dimensiona los bloques obtenidos
     * @param n = La zona
     * @param c = El caracter a buscar
     * @param f = El indice fila por donde buscar
     * @param i = La imagen a introducir con el bloque
     */
    private int cantidad = 0;

    private void buscarPorFila(char[] n, char c, int f) {
        int inicio = 0;
        int contador = 0;
        // Se recorre la fila 
        for (int j = 0; j <= n.length - 1; j++) {
            if (n[j] == c) {
                if (inicio == 0) {
                    inicio = j;
                }
                // El contador es para saber cuantos bloques de ese mismo 
                // son iguales
                contador++;
            } else {
                if (inicio != 0) {
                    // En el momento que no haya iguales se crea el nuevo bloque
                    bloques.add(new Bloque(inicio * 50, f * 50,
                            contador * 50, 50));
                    System.out.println("Bloque " + this.cantidad + "\nPosicion: (" + inicio * 50 + "," + f * 50 + ")");
                    this.cantidad++;
                    contador = 0;
                    inicio = 0;
                }
            }

        }
    }
}
